# -*- coding: utf-8 -*-

"""
Module implementing MainWindow.
"""

from PyQt4.QtGui import QMainWindow, QFileDialog, QMessageBox, QIcon
from PyQt4.QtCore import pyqtSignature, QString

from Ui_Synchronisation import Ui_MainWindow
import ConfigParser, os, datetime, glob, shutil, sys
from AutoIt import AutoIt
from FileParser import parserEnregistrerDonneesAccelero, parserEnregistrerTimestamperDonneesPlateforme
from VlcController import *



class MainWindow(QMainWindow, Ui_MainWindow):
    """
    Classe gérant la fenêtre principale de l'application
    """
    def __init__(self, parent=None):
        """
        Constructeur
        """
        
        QMainWindow.__init__(self, parent)
        self.setupUi(self)
        self.setWindowIcon(QIcon("synchronisation.png"))
        self.config = ConfigParser.ConfigParser()
        # on récupère les informations de configuration
        self.adresseConfig = os.path.join(os.path.abspath(os.curdir), 'config', 'configuration.cfg')
        self.config.readfp(open(self.adresseConfig))
        self.dossierParDefaut = self.config.get('General', 'dossierParDefaut')
        self.cheminVlc = self.config.get('General', 'cheminVlc')
        if self.cheminVlc == "":
            reponse = QMessageBox.warning(None, self.trUtf8("VLC"), self.trUtf8("""Attention ! Le chemin de vlc n'est pas renseigné dans le fichier de configuration ! Veuillez le spécifier si vous souhaitez faire de la capture vidéo."""),
            QMessageBox.StandardButtons(QMessageBox.Cancel | QMessageBox.Open))
            if reponse == QMessageBox.Open:
                self.cheminVlc = str(QFileDialog.getOpenFileName(None, self.trUtf8("Exécutable vlc"), QString(), self.trUtf8("*.exe"), None))
                self.config.set('General', 'cheminVlc', self.cheminVlc)
                self.config.write(open(os.path.join(os.path.abspath(os.curdir), 'config', 'configuration.cfg'), 'wb'))
            else:
                sys.exit()
            
        self.dossierEnregistrementChemin.setText(self.dossierParDefaut)
        self.dossierEnregistrementCourant = self.dossierParDefaut
        self.autoit = AutoIt()
        self.dateDebutEnregistrement = None
        self.nomFichierPlateforme = None 
        self.accelerometresCheminBase = None
        self.nom = None
        self.prenom = None
        self.plateforme = True
        self.accelerometres = True
    
    @pyqtSignature("")
    def on_plateformeCheckBox_clicked(self):
        """
        Activation ou non de l'acquisition en provenance de la plateforme
        """
        if self.plateformeCheckBox.isChecked():
            self.InformationGroupBox.setEnabled(True)
            self.lancerAcquisitionBtn.setEnabled(False)
            self.dureeAccelerometresLabel.setEnabled(False)
            self.dureeAccelerometresSpinBox.setEnabled(False)
            self.plateforme = True
        else:
            self.InformationGroupBox.setEnabled(False)
            self.lancerAcquisitionBtn.setEnabled(True)
            self.dureeAccelerometresLabel.setEnabled(True)
            self.dureeAccelerometresSpinBox.setEnabled(True)
            self.plateforme = False
        # si ni le bouton de plateforme, ni le bouton des accéléromètres n'est activé, on empêche l'acquisition
        if not self.plateformeCheckBox.isChecked() and not self.accelerometresCheckBox.isChecked():
            self.lancerAcquisitionBtn.setEnabled(False)
            
    @pyqtSignature("")
    def on_accelerometresCheckBox_clicked(self):
        """
        Activation ou non de l'acquisition des accéléromètres
        """
        if self.accelerometresCheckBox.isChecked():
            self.accelerometres = True
            if not self.plateformeCheckBox.isChecked():
                self.lancerAcquisitionBtn.setEnabled(True)
        else:
            self.accelerometres = False
        # si ni le bouton de plateforme, ni le bouton des accéléromètres n'est activé, on empêche l'acquisition
        if not self.plateformeCheckBox.isChecked() and not self.accelerometresCheckBox.isChecked():
            self.lancerAcquisitionBtn.setEnabled(False)

    
    @pyqtSignature("")
    def on_informationsBtn_clicked(self):
        """
        Lorsque l'on clique sur le bouton de récupération d'informations, on récupère la valeur du nom, du prénom, de la fréquence et de la durée
        d'acquisition depuis Satel et on les met dans les attributs.
        Le bouton de lancement de l'acquisition devient alors cliquable.
        Si l'on clique sur le bouton d'identité alors que le logiciel n'est pas lancé, on lance une boîte de dialogue prévenant l'utilisateur.
        """
        if self.autoit.autoit.WinExists("[REGEXPTITLE:.*Satel.*]"):
            self.nom, self.prenom = self.autoit.obtenirIdentite()
            self.identiteLabel.setText(self.nom + " " + self.prenom)
            if self.autoit.estAcquisitionStatiqueOuDynamique():
                if self.autoit.estAcquisitionStatique():
                    self.typeAcquistionValeurLabel.setText("Statique")
                elif self.autoit.estAcquisitionDynamique():
                    self.typeAcquistionValeurLabel.setText("Dynamique")
                self.frequenceLabel.setText(u"Fréquence : %d" % self.autoit.frequenceAcquisitionPlateforme(self.autoit.estAcquisitionStatique()))
                self.dureeLabel.setText(u"Durée : %d" % self.autoit.dureeAcquisitionPlateforme(self.autoit.estAcquisitionStatique()))
                self.lancerAcquisitionBtn.setEnabled(True)
            else:
                QMessageBox.warning(None,
                self.trUtf8("Attention !"),
                self.trUtf8("L'application Satel n'est pas prête à acquérir des données. Placez vous dans l'onglet « Stabilométrie statique » ou « Stabilométrie dynamique » puis lancez une nouvelle mesure."), QMessageBox.StandardButtons(QMessageBox.Ok))
                self.nom, self.prenom = None, None
                self.frequenceLabel.setText(u"Fréquence : ??")
                self.dureeLabel.setText(u"Durée : ??")
                self.lancerAcquisitionBtn.setEnabled(False)
                self.typeAcquistionValeurLabel.setText("??")
        else:
            QMessageBox.warning(None,
            self.trUtf8("Attention !"),
            self.trUtf8("L'application Satel n'est pas lancée. Lancez-la afin de récupérer l'identité du sujet"), QMessageBox.StandardButtons(QMessageBox.Ok))
            self.nom, self.prenom = None, None
            self.identiteLabel.setText(u"NOM Prénom")
            self.lancerAcquisitionBtn.setEnabled(False)

    
    
    @pyqtSignature("")
    def on_destinationDefautBtn_clicked(self):
        """
        Lorsque l'on clique sur le bouton « valeur par défaut », on remplace le champ dossierEnregistrementChemin par la valeur récupérée dans le fichier de configuration.
        """
        self.dossierEnregistrementChemin.setText(self.dossierParDefaut)

    @pyqtSignature("")
    def on_dossierBtn_clicked(self):
        """
        Bouton permettant de sélectionner le dossier d'enregistrement.
        """
        nomDossier = QFileDialog.getExistingDirectory(None, self.trUtf8("Dossier de destination"), self.dossierParDefaut, QFileDialog.Options(QFileDialog.ShowDirsOnly))
        self.dossierEnregistrementChemin.setText(nomDossier)

    
    @pyqtSignature("")
    def on_lancerAcquisitionBtn_clicked(self):
        """
        Bouton permettant de lancer l'acquisition.
        """
        if int(self.autoit.autoit.ControlCommand("MotionDevTool", "", "[CLASS:Button; INSTANCE:24]", "IsVisible", "")) == 0 and self.accelerometres:
            QMessageBox.warning(None,
                                self.trUtf8("Attention !"),
                                self.trUtf8("Placez-vous dans l'onglet « Values » du MotionDevTool avant de lancer l'acquisition."),
                                QMessageBox.StandardButtons(QMessageBox.Ok))
        
        elif int(self.autoit.autoit.ControlCommand("[REGEXPTITLE:Examen.*]", "", "[CLASS:TButton; INSTANCE:2]", "IsVisible", ""))==0 and self.plateforme:
            QMessageBox.warning(None,
                                self.trUtf8("Attention !"),
                                self.trUtf8("La fenêtre d'Acquisition de la plateforme ne doit pas être minimisée pour lancer l'acquisition."),
                                QMessageBox.StandardButtons(QMessageBox.Ok))
                        
        # si on peut lancer l'acquisition sur les outils sélectionnés, on le fait. Sinon, on ouvre une boite de dialogue
        elif (self.autoit.estPretAAcquerir(self.plateforme, self.accelerometres)):
            suffixe = ".txt"
            if self.plateformeCheckBox.isChecked():
                estStatique = self.autoit.estAcquisitionStatique()
                if estStatique:
                    suffixe = "_statique.txt"
                else:
                    suffixe = "_dynamique.txt"
        
            self.lancerAcquisitionBtn.setEnabled(False)
            
            dateDebutVideo = datetime.datetime.now()
            
            if self.enregistrementVideoCheckBox.isChecked():
                if not self.plateformeCheckBox.isChecked():
                    vlc = VlcInstance(optionsEnregistrement(os.path.join(str(self.dossierEnregistrementChemin.text()), dateDebutVideo.strftime("%Y-%m-%d_%H-%M-%S_") + "video.avi"), self.cheminVlc))
                else:
                    vlc = VlcInstance(optionsEnregistrement(os.path.join(str(self.dossierEnregistrementChemin.text()), dateDebutVideo.strftime("%Y-%m-%d_%H-%M-%S_") + "%s_%s_" % (self.nom, self.prenom) + "video.avi"), self.cheminVlc))
                
                vlc.start()
                self.autoit.autoit.WinWait(("[REGEXPTITLE:.*VLC.*]"))
            
            # on prépare l'enregistrement
            self.dateDebutEnregistrement = datetime.datetime.now()

            sortie = self.dossierEnregistrementChemin.text()
            if sortie[-1] != "\\":
                sortie += "\\"
                
            if self.plateforme:
                self.accelerometresCheminBase = sortie + self.dateDebutEnregistrement.strftime("%Y-%m-%d_%H-%M-%S_") + "%s_%s_accelero%s" % (self.nom, self.prenom, suffixe)
            else :
                self.accelerometresCheminBase = sortie + self.dateDebutEnregistrement.strftime("%Y-%m-%d_%H-%M-%S_") + "accelero%s" % suffixe
                
            self.autoit.setCheminSortieAccelerometres(self.accelerometresCheminBase)
            self.autoit.activerTimestampAccelerometres()
            self.autoit.activerAllSensorsAccelerometres()
            
            # on lance l'acquisition !
            if self.accelerometres:
                self.autoit.lancerEnregistrementAccelerometres()
            if self.plateforme: 
                self.autoit.lancerAcquisitionPlateforme(estStatique)
            
            
            self.statusBar.showMessage(u"Démarrage : " + self.dateDebutEnregistrement.strftime("%d/%m/%Y %H:%M:%S"))
            if self.plateforme: 
                time.sleep(self.autoit.dureeAcquisitionPlateforme(estStatique))
            else:
                time.sleep(self.dureeAccelerometresSpinBox.value())
                self.lancerAcquisitionBtn.setEnabled(True)

            # on arrête les capteurs d'accéléromètre et on exporte les données

            if self.accelerometres:
                self.autoit.arreterEnregistrementAccelerometres()
                if not self.plateforme:
                    self.statusBar.showMessage(u"Terminé !")            
            if self.plateforme:
                self.autoit.enregistrerDonneesPlateformeDansBD(estStatique)
                self.nomFichierPlateforme = self.autoit.exporterResultats(str(sortie), self.dateDebutEnregistrement.strftime("%Y-%m-%d_%H-%M-%S_") + "%s_%s_plateforme_brute" % (self.nom, self.prenom), estStatique)
            
        else:
            QMessageBox.warning(None,
                                self.trUtf8("Attention !"),
                                self.trUtf8("""Les applications ne sont pas prêtes à effectuer une acquisition. Assurez-vous d'avoir bien fait une pré-acquisition sur Satel et d'avoir débuté la transmission sur le MotionDevTool le cas échéant, puis lancer à nouveau."""),
                                QMessageBox.StandardButtons(QMessageBox.Ok))


    @pyqtSignature("")
    def on_finalisationBtn_clicked(self):
        """
        Permet de tronquer le début des enregistrements si nécessaires
        """
        if not self.dateDebutEnregistrement or (self.plateforme and not self.nomFichierPlateforme) or (self.accelerometres and not self.accelerometresCheminBase):
            QMessageBox.warning(None,
                self.trUtf8("Attention !"),
                self.trUtf8("""Il n'y a pas encore eu d'enregistrements effectués, il est donc impossible d'ajuster vos données."""),
                QMessageBox.StandardButtons(QMessageBox.Ok))
        else:
            sortie = self.dossierEnregistrementChemin.text()
            if sortie[-1] != "\\":
                sortie += "\\"
                
            suffixe = ".txt"
            if self.plateforme:
                if self.autoit.estAcquisitionStatique():
                    suffixe = "_statique.txt"
                else:
                    suffixe = "_dynamique.txt"

            date = self.dateDebutEnregistrement + datetime.timedelta(seconds=self.ajustementDebutBox.value())
            try:
                if self.accelerometres and self.ajustementDebutBox.value()!=0:
                    if self.plateforme:
                        parserEnregistrerDonneesAccelero(str(self.accelerometresCheminBase), date, self.nom, self.prenom)
                    else:
                        parserEnregistrerDonneesAccelero(str(self.accelerometresCheminBase), date)
                        
                if self.plateforme:
                    parserEnregistrerTimestamperDonneesPlateforme(self.nomFichierPlateforme, self.autoit.frequenceAcquisitionPlateforme(self.autoit.estAcquisitionStatique()), self.dateDebutEnregistrement, date)
            except IOError:
                QMessageBox.warning(None,
                self.trUtf8("Attention !"),
                self.trUtf8("""Impossible d'ouvrir les fichiers. Il y a dû avoir une erreur lors de l'enregistrement."""),
                QMessageBox.StandardButtons(QMessageBox.Ok))

            cheminDossier = str(sortie)
            listeADeplacer = []
            if self.plateforme:
                listeADeplacer += [str(self.nomFichierPlateforme)]
            if self.accelerometresCheminBase and self.ajustementDebutBox.value()!=0:
                listeADeplacer += glob.glob(os.path.splitext(str(self.accelerometresCheminBase))[0]+"*")
            if not os.path.exists(os.path.join(cheminDossier, "save")):
                os.mkdir(os.path.join(cheminDossier, "save"))
            for element in listeADeplacer:
                try:
                    shutil.move(element, os.path.join(cheminDossier, "save", os.path.basename(element)))
                except:
                    QMessageBox.warning(None,
                                        self.trUtf8("Attention !"),
                                        self.trUtf8("Impossible de déplacer l'élément %s." % os.path.basename(element)),
                                        QMessageBox.StandardButtons(QMessageBox.Ok))
            self.statusBar.showMessage("Timestamping terminé !")
    
    @pyqtSignature("")
    def on_nouvelleValeurBtn_clicked(self):
        """
        Option du menu permettant d'enregistrer l'emplacement courant comme nouvel emplacement par défaut
        """
        self.config.set('General', 'dossierpardefaut', self.dossierEnregistrementChemin.text())
        self.config.write(open(self.adresseConfig, 'wb'))
        self.dossierParDefaut = self.dossierEnregistrementChemin.text()
    
    @pyqtSignature("")
    def on_enregistrementVideoCheckBox_clicked(self):
        """
        """
        if self.enregistrementVideoCheckBox.isChecked():
            self.testEnregistrementBtn.setEnabled(True)
        else:
            self.testEnregistrementBtn.setEnabled(False)
        
    @pyqtSignature("")
    def on_testEnregistrementBtn_clicked(self):
        """
        lancement du test d'enregistrement vidéo, enregistré dans le dossier de base
        """
        dateDebut = datetime.datetime.now()
        vlc = VlcInstance(optionsEnregistrement(os.path.join(str(self.dossierEnregistrementChemin.text()), dateDebut.strftime("%Y-%m-%d_%H-%M-%S_test_video.avi")), self.cheminVlc))
        vlc.start()
    
    @pyqtSignature("")
    def on_action_a_propos_triggered(self):
        """
        Bouton « À propos » lançant une petite boîte d'information sur le logiciel
        """
        QMessageBox.about(None,
            self.trUtf8("À propos de Synchronisation"),
            self.trUtf8("""Ceci est un petit logiciel permettant la synchronisation des données provenant d'une plateforme de forces et d'accéléromètres.

http://synchronisation-cetaps.googlecode.com"""))
